package com.taoge.p4.common.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.taoge.p4.common.constants.RedisKeyConstant;
import com.taoge.p4.common.vo.BrandVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import java.lang.reflect.Type;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类 - 专注于StringRedisTemplate操作
 *
 * @author mip
 */
@Slf4j
public class RedisUtil {

    public static final StringRedisTemplate STRING_REDIS_TEMPLATE = SpringContextUtils.getBean("stringRedisTemplate", StringRedisTemplate.class);

    /**
     * 设置缓存并指定过期时间
     *
     * @param key   缓存键
     * @param value 缓存值
     * @param time  过期时间(秒)
     * @return 操作结果
     */
    public static boolean set(String key, String value, long time) {
        try {
            ValueOperations<String, String> ops = STRING_REDIS_TEMPLATE.opsForValue();
            if (time > 0) {
                ops.set(key, value, time, TimeUnit.SECONDS);
            } else {
                ops.set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace(); // 或者使用日志记录异常信息
            return false;
        }
    }


    /**
     * 获取缓存
     *
     * @param key 缓存键
     * @return 缓存值
     */
    public static JSONObject get(String key) {
//        ValueOperations<String, String> ops = STRING_REDIS_TEMPLATE.opsForValue();
//        return ops.get(key);
        String s = STRING_REDIS_TEMPLATE.opsForValue().get(key);
        if (s==null){
            return null;
        }
        return JSON.parseObject(s);
    }

    /**
     * 删除指定键的缓存
     *
     * @param key 缓存键
     * @return 操作是否成功
     */
    public static boolean remove(String key) {
        try {
            STRING_REDIS_TEMPLATE.delete(key);
            return true;
        } catch (Exception e) {
            e.printStackTrace(); // 或者使用日志记录异常信息
            return false;
        }
    }

    /**
     * 判断key是否存在
     *
     * @param key 缓存键
     * @return 是否存在
     */
    public static Boolean hasKey(String key) {
        return STRING_REDIS_TEMPLATE.hasKey(key);
    }

    /**
     * 设置缓存过期时间
     *
     * @param key  缓存键
     * @param time 过期时间(秒)
     * @return 操作结果
     */
    public static Boolean expire(String key, long time) {
        if (time > 0) {
            return STRING_REDIS_TEMPLATE.expire(key, time, TimeUnit.SECONDS);
        }
        return false;
    }

    /**
     * 根据key获取过期时间
     *
     * @param key 缓存键
     * @return 过期时间(秒)，如果为-1表示永久有效
     */
    public static Long getExpire(String key) {
        return STRING_REDIS_TEMPLATE.getExpire(key, TimeUnit.SECONDS);
    }


    /**
     * 设置缓存并指定过期时间
     *
     * @param key   缓存键
     * @param value 缓存值
     * @param time  过期时间(秒)
     * @return 操作结果
     */
    public static <T> boolean set(String key, T value, long time) {
        try {
            // 将对象转换为JSON字符串
            String jsonString = JSON.toJSONString(value);
            ValueOperations<String, String> ops = STRING_REDIS_TEMPLATE.opsForValue();
            ops.set(key, jsonString);
            if (time > 0) {
                // 设置过期时间
                STRING_REDIS_TEMPLATE.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace(); // 或者使用日志记录异常信息
            return false;
        }
    }

    /**
     * 获取缓存，并将其反序列化为指定的泛型类型
     *
     * @param key          缓存键
     * @param typeReference 类型引用
     * @param <T>          泛型类型
     * @return 反序列化后的对象
     */
    public static <T> T get(String key, TypeReference<T> typeReference) {
        String s = STRING_REDIS_TEMPLATE.opsForValue().get(key);
        if (s == null) {
            return null;
        }
        try {
            return JSON.parseObject(s, typeReference);
        } catch (Exception e) {
            e.printStackTrace(); // 或者使用日志记录异常信息
            return null;
        }
    }

}